/**
 * 获得两点之前可以连接的路径点，不包含起点，包含终点
 * @param {number} start_x 起始点x
 * @param {number} start_y 起始点y
 * @param {number} end_x 目标点x
 * @param {number} end_y 目标点y
 * @param {{rows, cols, arr}} MAP 地图配置
 * @returns {{x:number,y:number}[]} 返回路径点数组
 */
export function searchRoad(start_x, start_y, end_x, end_y, MAP) {
    let openList = [], //开启列表，待搜索的点
        closeList = [], //关闭列表，已搜索过的点
        result = [], //结果数组
        result_index; //结果数组在开启列表中的序号

    openList.push({ x: start_x, y: start_y, G: 0 }); //把当前点加入到开启列表中，并且G是0

    do {
        let currentPoint = openList.pop();
        closeList.push(currentPoint);
        let surroundPoint = SurroundPoint(currentPoint); // 八个方向的寻路
        // let surroundPoint = SurroundHalfPoint(currentPoint); // 四个方向的寻路
        for (let i in surroundPoint) {
            let item = surroundPoint[i]; //获得周围的八个点
            if (
                isInMap(item, MAP) &&
                MAP.arr[item.x][item.y] !== 1 && //判断是否是障碍物
                existList(item, closeList) === false && //判断是否在关闭列表中
                MAP.arr[item.x][currentPoint.y] != 1 && //判断之间是否有障碍物，如果有障碍物是过不去的
                MAP.arr[currentPoint.x][item.y] != 1
            ) {
                //g 到父节点的位置
                //如果是上下左右位置的则g等于10，斜对角的就是14
                let g = currentPoint.G + ((currentPoint.x - item.x) * (currentPoint.y - item.y) == 0 ? 10 : 14);
                // 如果item不在待搜索的列表中，则说明是新增加的待搜索点，将其加入到待搜索列表中
                if (existList(item, openList) === false) {
                    //如果不在开启列表中
                    //计算H，通过水平和垂直距离进行确定
                    item['H'] = Math.abs(end_x - item.x) * 10 + Math.abs(end_y - item.y) * 10;
                    item['G'] = g;
                    item['F'] = item.H + item.G;
                    item['parent'] = currentPoint;
                    openList.push(item);
                } else {
                    //存在在开启列表中，比较目前的g值和之前的g的大小
                    let index = existList(item, openList);
                    //如果当前点的g更小
                    if (g < openList[index].G) {
                        openList[index].parent = currentPoint;
                        openList[index].G = g;
                        openList[index].F = g + openList[index].H;
                    }
                }
            }
        }
        //如果开启列表空了，没有通路，结果为空
        if (openList.length === 0) {
            break;
        }
        openList.sort(sortF); //这一步是为了循环回去的时候，找出 F 值最小的, 将它从 "开启列表" 中移掉
    } while (!(result_index = existList({ x: end_x, y: end_y }, openList))); // 如果结束点在出现在被搜索的列表中，则说明找到了一条路径

    //判断结果列表是否为空
    if (!result_index) {
        result = [];
    } else {
        let currentObj = openList[result_index];
        do {
            //把路劲节点添加到result当中
            result.unshift({
                x: currentObj.x,
                y: currentObj.y,
            });
            currentObj = currentObj.parent;
        } while (currentObj.x != start_x || currentObj.y != start_y);
    }
    return result;
}

//用F值对数组排序
export function sortF(a, b) {
    return b.F - a.F;
}

/**
 * 获取周围上下左右四个点的值
 * @param {*} curPoint 当前点坐标
 * @returns 从上面的点开始，按照顺时针
 */
export function SurroundHalfPoint(curPoint) {
    let x = curPoint.x,
        y = curPoint.y;
    return [
        { x: x, y: y - 1 },
        { x: x + 1, y: y },
        { x: x, y: y + 1 },
        { x: x - 1, y: y },
    ];
}

/**
 * 获取周围八个点的值
 * @param {*} curPoint 当前点坐标
 * @returns 周围八个点组成的一维数组 ，从左上角开始，按照顺时针
 */
export function SurroundPoint(curPoint) {
    let x = curPoint.x,
        y = curPoint.y;
    return [
        { x: x - 1, y: y - 1 },
        { x: x, y: y - 1 },
        { x: x + 1, y: y - 1 },
        { x: x + 1, y: y },
        { x: x + 1, y: y + 1 },
        { x: x, y: y + 1 },
        { x: x - 1, y: y + 1 },
        { x: x - 1, y: y },
    ];
}

/**
 * //判断是否在地图上
 * @param {{x:number,y:number}} item
 * @param {*} MAP
 * @returns {boolean} true表示在地图上
 */
export function isInMap(item, MAP) {
    return (
        item.x >= 0 && //判断是否在地图上
        item.y >= 0 &&
        item.x < MAP.rows &&
        item.y < MAP.cols
    );
}

/**
 * 判断点是否存在在列表中，是的话返回的是序列号，不在列表中则返回false
 * @param {*} point 要检查的点
 * @param {Array} list 被检查的数组
 * @returns
 */
export function existList(point, list) {
    let index = list.findIndex(item => item.x === point.x && item.y === point.y);
    return index === -1 ? false : index;
}

/**
 * 画一个矩形
 * @param {CanvasRenderingContext2D} ctx 画笔
 * @param {number} x
 * @param {number} y
 * @param {number} width
 * @param {number} height
 * @param {string} color
 * @param {boolean} isStroke 是否绘制边框类型，否则就为填充类型
 */
export function drawRect(ctx, x, y, width, height, color = 'gray', isStroke = false) {
    ctx.fillStyle = color;
    if (isStroke) {
        ctx.strokeRect(x, y, width, height);
    } else {
        ctx.fillRect(x, y, width, height);
    }
}

/**
 * 画一条线
 * @param {CanvasRenderingContext2D} ctx
 * @param {number} start_x
 * @param {number} start_y
 * @param {number} end_x
 * @param {number} end_y
 * @param {number} lineWidth
 * @param {string} color
 */
export function drawLine(ctx, start_x, start_y, end_x, end_y, lineWidth = 2, color = 'red') {
    ctx.fillStyle = color;
    ctx.lineWidth = lineWidth;
    ctx.beginPath();
    ctx.moveTo(start_x, start_y);
    ctx.lineTo(end_x, end_y);
    ctx.stroke();
}

/**
 * 生成范围内随机整数
 * @param {number} start
 * @param {number} end
 */
export function getRandomInit(start = 0, end = 10) {
    start = Math.ceil(start);
    end = Math.floor(end);
    return Math.floor(Math.random() * (end - start + 1)) + start;
}

/**
 * 生成在地图上不为障碍物的一个随机点
 * @param {*} MAP 地图配置对象
 * @returns
 */
export function createRandomMapPoint(MAP) {
    let x = getRandomInit(0, MAP.rows - 1);
    let y = getRandomInit(0, MAP.cols - 1);
    // 判断生成的点是否是障碍物所在的点，是的话，需要重新生成
    while (MAP.arr[x][y] === 1) {
        x = getRandomInit(0, MAP.rows - 1);
        y = getRandomInit(0, MAP.cols - 1);
    }
    return { x, y };
}
